/******************************************************
Cours:   LOG121
Session: A2013
Groupe:  
Projet: Laboratoire #3
etudiant(e)s: Simon Castro
			  Fredy Alexander 
			  Renaud Vincent
              
              
Professeur : 
Nom du fichier: CalculScreBunco.java
Date cree: 2013-11-11
Date dern. modif. 2013-11-11
*******************************************************
Historique des modifications
*******************************************************
2013-10-20 Version 1.0
*******************************************************/ 

package bunco;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Collection;
import cadricielJeuDe.CalculateurScore;
import cadricielJeuDe.CollectionJoueurs;
import cadricielJeuDe.Joueur;

/**
 * La classe CalculScoreBunco implemente la classe abstraire CalculateurScore
 * du cardiciel JeuDe. Elle possede les deux methodes calculScoreTour(), et 
 * calculerLeVainqueur(). Elle est en charge de comptabiliser les points apres 
 * un lancer de de selon les regles de Bunco+, et trie les joueurs selon leur
 * score. 
 * 
 * @author FABS
 *
 */
public class CalculScoreBunco implements CalculateurScore{
	
	/**
	 * Constructeur par default
	 */
	public CalculScoreBunco(){};
	
	/************
	 * Methodes
	 ************/
	
	/**
	 * Methode calculScoreTour: Elle valide le pointage obtenu selon le tour
	 * actuelle et les de obtenus, par rapport aux regles de bunco.
	 * 
	 * @param tour
	 * @param listeValeurs
	 * @return passerMain
	 */
	@Override
	public Object calculScoreTour(int tour, ArrayList<Integer> listeValeurs) {
		
		int validateur=0;
		int indicateurEgale=0;
		ResultatValide rv = new ResultatValide();
		
		System.out.println("Au tour "+tour+" "+ listeValeurs.toString());
		
		/*
		 * On parcrous les elements de la liste, si chaque element sont egale
		 * au numero du tour actuel, le validateur s'incremente.
		 */
		for(int i=0; i<listeValeurs.size(); i++){
			
			if(listeValeurs.get(i) == tour)
				validateur++;
		}
		indicateurEgale = listeValeurs.get(0);
		
		//Nous obtenus un bunco si le validateur sest incrementee pour chaque 
		//element de la liste.
		if(validateur == listeValeurs.size()){
			rv.setPoints(21);
			rv.setPasserMain(true);
		}
		//Si le validateur a detecte une egalite avec le numero de tour au moins
		//une fois, sans qu'il y ait un bunco, alors le nombre de point est egale
		//au nombre de fois qu'il y d'occurence.
		else if (validateur != 0 && validateur < listeValeurs.size()){
			rv.setPoints(validateur);
			rv.setPasserMain(false);
		}
		
		//Cas ou on obtient trois des pareil mais different du tour.
		else if(listeValeurs.get(0) == listeValeurs.get(1) && listeValeurs.get(2) ==
				listeValeurs.get(1) && indicateurEgale != tour){
			rv.setPoints(5);
			rv.setPasserMain(false);
		}
		else{
			rv.setPoints(0);
			rv.setPasserMain(true);
		}
		
		return (Object)rv;
	}


	/**
	 * Methode qui triee les score selon leur score en decroissant 
	 * 
	 * @param cj
	 * @return la Collection triee
	 */
	@Override
	public CollectionJoueurs calculerLeVainqueur(CollectionJoueurs cj) {
		
		CollectionJoueurs cjTriee = new CollectionJoueurs();
		Joueur [] temp = new Joueur[cj.getTaille()];
		
		//Transfert
		for(int i=0; i<cj.getTaille(); i++){
			temp[i] = cj.getJoueurAt(i);
		}
		
		//Triage du tableau de joueurs en ordre croissant.
		Arrays.sort(temp);
		
		//Transfert a l'inverse
		int indice = temp.length-1;
		for(int i=0; i<temp.length; i++){
			cjTriee.ajouterJoueur(temp[indice-i]);
		}
		
		return cjTriee;
	}


}
